home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 050 / bix03.arc / ZAP.PAS < prev   
Pascal/Delphi Source File  |  1986-08-04  |  7KB  |  307 lines
  1. (*ZAP.PAS/Turbo/MS/PCDOS/IBM & Clones - Browse & Patch files in Hex & Ascii.
  2. ***moved here from Turbo #1470 due to its size.  - Jim Keohane
  3. Here's a little quickie I use when I want to see the Ascii and hex
  4. contents of a file. You compile to .COM file and type "zap filename.ext".
  5. You get prompted for a block number starting with zero (1st block). You
  6. will be shown the contents of the selected 512 byte block on your screen.
  7. At this point ESC will get you back to the "Enter Block No..." and
  8. hitting F10 will make the program end. You can also EDIT the block by
  9. skipping around (use arrows on numeric keypad) and typing over any char
  10. you want to change. You can type most normal Ascii characters and any
  11. unusual ones can be entered in hex. The updated block will not be written
  12. back to the file unless you hit F1.
  13.   This was a quick-and-dirty I put together so play with the code and add
  14. some improvements. One problem is that if you rewrite the last block on
  15. the file I set the new file length to a multiple of 512. This enables you
  16. to add some info to most files but it should be a lot cleaner. Perhaps
  17. one of you could fix this. The "dump" of the current block shows 64 chars
  18. across. First is Ascii and underneath is the hex...
  19.                            A
  20.                            4
  21.                            1
  22.  
  23. The block number shows at top left. If you type a block number that's
  24. past the end of the file the prompt will repeat.   - Jim
  25. *)
  26. Program zap;
  27.  
  28. Type
  29.     RegType = record case integer of
  30.               0:(Ax,Bx,Cx,Dx,Bp,Si,Di,Ds,Es,Flags:integer);
  31.               1:(Al,Ah,Bl,Bh,Cl,Ch,Dl,Dh:byte);
  32.               2:(words:array[0..9] of integer);
  33.               3:(bytes:array[0..7] of byte)
  34.               end;
  35.  
  36. type block = array[0..7] of record row:array[0..63] of byte end;
  37.      str3=string[3];
  38. const hex:array[0..15] of char = '0123456789ABCDEF';
  39.       hexs:string[15]='123456789ABCDEF';
  40.  
  41. var f:file of block;
  42. blk:block;
  43. c:char;
  44. blkno,x,y,z:integer;
  45.  
  46. function three(i:integer):str3;
  47. begin three:=hex[hi(i)]+hex[lo(i) shr 4] + hex[lo(i) and $f] end;
  48.  
  49. procedure manager(which:byte);
  50. const LeftArrow='L';RightArrow='R';Home='H';Endd='E';
  51.       UpArrow='u';DownArrow='d';
  52.       PgUp='U';PgDn='D';Ins='+';Del='-';BackTab='B';ForwardTab='F';
  53.       numpad:string[13]='HuU?L?R?EdD+-';
  54.       cnumpad:string[18]='LREDH????????????U';
  55.       toprow:string[12]='1234567890-=';
  56.       qwerty:string[35]='qwertyuiop????asdfghjkl?????zxcvbnm';
  57. var ch:char;
  58. begin
  59. ch:='?';
  60. case which of
  61. 16..25,30..38,44..50,120..131:
  62.    begin {Alt keys}
  63.     if which>=120 then ch:=toprow[which-119] else ch:=qwerty[which-15];
  64.     case ch of
  65.     'a':;
  66.     'b':;
  67.     'c':;
  68.     'd':;
  69.     'e':;
  70.     'f':;
  71.     'g':;
  72.     'h':;
  73.     'i':;
  74.     'j':;
  75.     'k':;
  76.     'l':;
  77.     'm':;
  78.     'n':;
  79.     'o':;
  80.     'p':;
  81.     'q':;
  82.     'r':;
  83.     's':;
  84.     't':;
  85.     'u':;
  86.     'v':;
  87.     'x':;
  88.     'y':;
  89.     'z':;
  90.     '0':;
  91.     '1':;
  92.     '2':;
  93.     '3':;
  94.     '4':;
  95.     '5':;
  96.     '6':;
  97.     '7':;
  98.     '8':;
  99.     '9':;
  100.     end;
  101.    end;
  102. 104..113:case which-103 of {alt function keys}
  103.           1:;
  104.           2:;
  105.           3:;
  106.           4:;
  107.           5:;
  108.           6:;
  109.           7:;
  110.           8:;
  111.           9:;
  112.           10:;
  113.          end;
  114. 59..68:case which-58 of {function keys}
  115.           1:begin seek(f,blkno);write(f,blk) end;
  116.           2:;
  117.           3:;
  118.           4:;
  119.           5:;
  120.           6:;
  121.           7:;
  122.           8:;
  123.           9:;
  124.           10:begin close(f); halt end;
  125.          end;
  126. 84..93:case which-83 of {shift function keys}
  127.           1:;
  128.           2:;
  129.           3:;
  130.           4:;
  131.           5:;
  132.           6:;
  133.           7:;
  134.           8:;
  135.           9:;
  136.           10:;
  137.          end;
  138. 94..103:case which-93 of {ctrl function keys}
  139.           1:;
  140.           2:;
  141.           3:;
  142.           4:;
  143.           5:;
  144.           6:;
  145.           7:;
  146.           8:;
  147.           9:;
  148.           10:;
  149.          end;
  150. 151..157,160..162,164..176:
  151.    case chr(which-54) of {ctrl keys}
  152.     'a':;
  153.     'b':;
  154.             {ctrl-c or ctrl-break is not intercepted}
  155.     'd':;
  156.     'e':;
  157.     'f':;
  158.     'g':;
  159.             {note: ctrl-h is taken to be backspace}
  160.     'i':;
  161.     'j':;
  162.     'k':;
  163.     'l':;
  164.             {note: ctrl-m is taken to be Enter [CR]}
  165.     'n':;
  166.     'o':;
  167.     'p':;
  168.     'q':;
  169.     'r':;
  170.     's':;
  171.     't':;
  172.     'u':;
  173.     'v':;
  174.     'x':;
  175.     'y':;
  176.     'z':;
  177.    end;
  178. 15,71..73,75,
  179. 77,79..83,159:
  180.    begin
  181.     if which=15 then ch:=BackTab else
  182.     if which=159 then ch:=ForwardTab else
  183.     ch:=numpad[which-70];
  184.     case ch of {numeric key pad keys}
  185.      BackTab:;
  186.      ForwardTab:;
  187.      Home:;
  188.      UpArrow:begin y:=pred(24+y*3+z) mod 24;z:=y mod 3;y:=y div 3 end;
  189.      PgUp:;
  190.      LeftArrow:if x=0 then x:=63 else x:=pred(x);
  191.      RightArrow:if x=63 then x:=0 else x:=succ(x);
  192.      Endd:;
  193.      DownArrow:begin y:=succ(y*3+z) mod 24;z:=y mod 3;y:=y div 3 end;
  194.      PgDn:;
  195.      Ins:;
  196.      Del:;
  197.     end;
  198.    end;
  199. 115..119,132:
  200.     begin
  201.      case cnumpad[which-114] of {ctrl-numeric key pad keys}
  202.       LeftArrow:;
  203.       RightArrow:;
  204.       Endd:;
  205.       PgDn:;
  206.       Home:;
  207.       PgUp:;
  208.      end;
  209.     end;
  210.  end;
  211.  gotoxy(x+7,1+y*3+z)
  212. end;
  213.  
  214. function kbchar:char;
  215. var r:regtype;
  216. begin
  217.  r.ah:=$0b;
  218.  msdos(r);
  219.  if r.al = 0 then kbchar:=#0
  220.  else begin
  221.        r.ah:=$07;
  222.        msdos(r);
  223.        if r.al<>0 then
  224.        if r.al in [8,13,27,32..127] then kbchar:=chr(r.al)
  225.        else begin manager(r.al+150);kbchar:=#0 end
  226.        else
  227.         begin
  228.          r.ah:=$07;
  229.          msdos(r);
  230.          manager(r.al);
  231.          kbchar:=#0
  232.         end;
  233.       end;
  234. end;
  235.  
  236.    procedure showchar;
  237.    var zz:integer;
  238.    begin
  239.     for zz:=0 to 2 do
  240.      begin
  241.       gotoxy(x+7,1+y*3+zz);
  242.       case zz of
  243.        0:write(chr(blk[y].row[x]));
  244.        1:write(hex[blk[y].row[x] shr 4]);
  245.        2:write(hex[blk[y].row[x] and 15])
  246.       end
  247.      end;
  248.     gotoxy(x+7,1+y*3+z)
  249.    end;
  250.  
  251. procedure showblk;
  252. begin
  253.  clrscr;
  254.  gotoxy(72,1);
  255.  write('#',BlkNo);
  256.  for y:=0 to 7 do
  257.   begin
  258.    gotoxy(1,1+y*3);
  259.    writeln(three(y*64));
  260.    writeln('to');
  261.    writeln(three(y*64+63));
  262.    for x:=0 to 63 do showchar;
  263.   end
  264. end;
  265.  
  266. procedure getblk;
  267. begin
  268.  clrscr;
  269.  repeat
  270.  gotoxy(1,1);
  271.  write('Block #?....');
  272.  readln(BlkNo);
  273.  gotoxy(1,1);
  274.  write('                           ');
  275.  {$I-}
  276.  seek(f,BlkNo);
  277.  read(f,Blk)
  278.  {$I+}
  279.  until ioresult=0
  280. end;
  281.  
  282. procedure editblk;
  283. begin
  284.  x:=0;y:=0;z:=0;
  285.  repeat
  286.  gotoxy(x+7,1+y*3+z);
  287.  repeat c:=kbchar until c<>#0;
  288.  if c<>^[ then
  289.   case z of
  290.    0:blk[y].row[x]:=ord(c);
  291.    1:blk[y].row[x]:=(blk[y].row[x] and 15) or (pos(upcase(c),hexs) shl 4);
  292.    2:blk[y].row[x]:=(blk[y].row[x] and 240) or pos(upcase(c),hexs)
  293.   end;
  294.  Showchar
  295.  until c=^[
  296. end;
  297. begin
  298. assign(f,paramstr(1));
  299. reset(f);
  300. repeat
  301. clrscr;
  302. getblk;
  303. showblk;
  304. editblk;
  305. until false;
  306. end.
  307.